/*
 * InvertedListRecordSerializer.cpp
 *
 *  Created on: Nov 29, 2012
 *      Author: m
 */

#include "InvertedListRecordSerializer.h"

namespace physical
{

InvertedListRecordSerializer::InvertedListRecordSerializer()
{
}

InvertedListRecordSerializer::~InvertedListRecordSerializer()
{
}

size_t InvertedListRecordSerializer::serialize(
        const InvertedListRecord& element, byteStream block )
{
    size_t usedBytes = 0;
    byte* blockPtr = block;
    // Serializo el id del término
    memcpy( blockPtr, &element.m_termID, sizeof(term_id_t) );
    usedBytes += sizeof(term_id_t);
    blockPtr += sizeof(term_id_t);
    // Serializo el tamaño del contenido ( como un entero de 1 byte )
    unsigned char contentSize = element.m_content.size();
    memcpy( blockPtr, &contentSize, sizeof(content_size_t) );
    usedBytes += sizeof(content_size_t);
    blockPtr += sizeof(content_size_t);
    // Copio directamente el contenido, porque ya es un array de bytes
    memcpy( blockPtr, &element.m_content.front(), contentSize );
    usedBytes += contentSize;
    blockPtr += contentSize;
    return usedBytes;
}

size_t InvertedListRecordSerializer::deserialize( const byteStream block,
        InvertedListRecord& element )
{
    content_size_t contentSize;
    byte* blockPtr = (byte*) block;

    size_t usedBytes = 0;
    byte content[128]; // TODO: SACAR ESTE 128 HARDCODEADO
    term_id_t termID;


    // Deserializo el id del término asociado a la lista invertida
    memcpy( &termID, blockPtr, sizeof(term_id_t) );

    usedBytes += sizeof(term_id_t);
    blockPtr += sizeof(term_id_t);


    // Deserializo el tamaño del contenido
    memcpy( &contentSize, blockPtr, sizeof(content_size_t) );

    usedBytes += sizeof(content_size_t);
    blockPtr += sizeof(content_size_t);


    // Deserializo el contenido (se copia directamente porque es un array de bytes)
    memcpy( &content, blockPtr, contentSize );

    usedBytes += contentSize;
    blockPtr += contentSize;
    element = InvertedListRecord( termID, content, contentSize );

    return usedBytes;
}

size_t InvertedListRecordSerializer::getSize(
        const InvertedListRecord& element )
{
    size_t usedBytes = 0;
    // tamaño del id del término
    usedBytes += sizeof(term_id_t);
    // tamaño del contenido ( como un entero de 1 byte )
    usedBytes += sizeof(content_size_t);
    // Tamaño del contenido, porque ya es un array de bytes
    usedBytes += element.m_content.size();
    return usedBytes;
}

} /* namespace physical */
